Termination w.r.t. Q proof of TRS/TRCSRExAppendixB_AEL03

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

PROPER₁(from₁(X)) -> FROM₁(proper₁(X))
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> CONS2₂(X, Z)
ACTIVE₁(from₁(X)) -> FROM₁(active₁(X))
PROPER₁(negrecip₁(X)) -> NEGRECIP₁(proper₁(X))
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(X1, active₁(X2))
S₁(mark₁(X)) -> S₁(X)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(X1, active₁(X2))
PROPER₁(pi₁(X)) -> PI₁(proper₁(X))
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(square₁(X)) -> SQUARE₁(active₁(X))
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
TOP₁(mark₁(X)) -> TOP₁(proper₁(X))
ACTIVE₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> RCONS₂(negrecip₁(Y), 2ndspos₂(N, Z))
2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(pi₁(X)) -> PI₁(active₁(X))
ACTIVE₁(pi₁(X)) -> 2NDSPOS₂(X, from₁(0))
ACTIVE₁(times₂(s₁(X), Y)) -> TIMES₂(X, Y)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(active₁(X1), X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(X1, active₁(X2))
PROPER₁(square₁(X)) -> SQUARE₁(proper₁(X))
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)
RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(active₁(X1), X2)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(square₁(X)) -> PROPER₁(X)
ACTIVE₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> 2NDSPOS₂(N, Z)
PROPER₁(s₁(X)) -> PROPER₁(X)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> NEGRECIP₁(active₁(X))
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)
SQUARE₁(mark₁(X)) -> SQUARE₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> 2NDSPOS₂(s₁(N), cons2₂(X, Z))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(proper₁(X1), proper₁(X2))
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> CONS2₂(X, Z)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)
ACTIVE₁(times₂(s₁(X), Y)) -> PLUS₂(Y, times₂(X, Y))
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(X1, active₁(X2))
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(active₁(X1), X2)
PI₁(ok₁(X)) -> PI₁(X)
PROPER₁(pi₁(X)) -> PROPER₁(X)
ACTIVE₁(cons₂(X1, X2)) -> CONS₂(active₁(X1), X2)
RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)
ACTIVE₁(cons2₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(pi₁(X)) -> FROM₁(0)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> 2NDSNEG₂(s₁(N), cons2₂(X, Z))
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
TOP₁(ok₁(X)) -> TOP₁(active₁(X))
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> TIMES₂(proper₁(X1), proper₁(X2))
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> FROM₁(s₁(X))
PROPER₁(cons2₂(X1, X2)) -> CONS2₂(proper₁(X1), proper₁(X2))
CONS2₂(X1, mark₁(X2)) -> CONS2₂(X1, X2)
PROPER₁(posrecip₁(X)) -> POSRECIP₁(proper₁(X))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(active₁(X1), X2)
NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> POSRECIP₁(Y)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(active₁(X1), X2)
2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
CONS2₂(ok₁(X1), ok₁(X2)) -> CONS2₂(X1, X2)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(X1, active₁(X2))
ACTIVE₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> NEGRECIP₁(Y)
FROM₁(mark₁(X)) -> FROM₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
TOP₁(ok₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
ACTIVE₁(cons2₂(X1, X2)) -> CONS2₂(X1, active₁(X2))
ACTIVE₁(s₁(X)) -> S₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(proper₁(X1), proper₁(X2))
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> RCONS₂(posrecip₁(Y), 2ndsneg₂(N, Z))
TOP₁(mark₁(X)) -> PROPER₁(X)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(square₁(X)) -> TIMES₂(X, X)
PI₁(mark₁(X)) -> PI₁(X)
PROPER₁(rcons₂(X1, X2)) -> RCONS₂(proper₁(X1), proper₁(X2))
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> 2NDSNEG₂(N, Z)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)
PROPER₁(s₁(X)) -> S₁(proper₁(X))
S₁(ok₁(X)) -> S₁(X)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
SQUARE₁(ok₁(X)) -> SQUARE₁(X)
ACTIVE₁(from₁(X)) -> CONS₂(X, from₁(s₁(X)))
CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)
ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(plus₂(s₁(X), Y)) -> PLUS₂(X, Y)
PROPER₁(plus₂(X1, X2)) -> PLUS₂(proper₁(X1), proper₁(X2))
TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
ACTIVE₁(posrecip₁(X)) -> POSRECIP₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> S₁(X)
NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)
PROPER₁(cons₂(X1, X2)) -> CONS₂(proper₁(X1), proper₁(X2))
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)
CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)
ACTIVE₁(plus₂(s₁(X), Y)) -> S₁(plus₂(X, Y))
FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(from₁(X)) -> FROM₁(proper₁(X))
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> CONS2₂(X, Z)
ACTIVE₁(from₁(X)) -> FROM₁(active₁(X))
PROPER₁(negrecip₁(X)) -> NEGRECIP₁(proper₁(X))
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(X1, active₁(X2))
S₁(mark₁(X)) -> S₁(X)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(X1, active₁(X2))
PROPER₁(pi₁(X)) -> PI₁(proper₁(X))
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(square₁(X)) -> SQUARE₁(active₁(X))
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
TOP₁(mark₁(X)) -> TOP₁(proper₁(X))
ACTIVE₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> RCONS₂(negrecip₁(Y), 2ndspos₂(N, Z))
2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(pi₁(X)) -> PI₁(active₁(X))
ACTIVE₁(pi₁(X)) -> 2NDSPOS₂(X, from₁(0))
ACTIVE₁(times₂(s₁(X), Y)) -> TIMES₂(X, Y)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(active₁(X1), X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(X1, active₁(X2))
PROPER₁(square₁(X)) -> SQUARE₁(proper₁(X))
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)
RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(active₁(X1), X2)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(square₁(X)) -> PROPER₁(X)
ACTIVE₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> 2NDSPOS₂(N, Z)
PROPER₁(s₁(X)) -> PROPER₁(X)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> NEGRECIP₁(active₁(X))
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)
SQUARE₁(mark₁(X)) -> SQUARE₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> 2NDSPOS₂(s₁(N), cons2₂(X, Z))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(proper₁(X1), proper₁(X2))
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> CONS2₂(X, Z)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)
ACTIVE₁(times₂(s₁(X), Y)) -> PLUS₂(Y, times₂(X, Y))
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(X1, active₁(X2))
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(active₁(X1), X2)
PI₁(ok₁(X)) -> PI₁(X)
PROPER₁(pi₁(X)) -> PROPER₁(X)
ACTIVE₁(cons₂(X1, X2)) -> CONS₂(active₁(X1), X2)
RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)
ACTIVE₁(cons2₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(pi₁(X)) -> FROM₁(0)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> 2NDSNEG₂(s₁(N), cons2₂(X, Z))
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
TOP₁(ok₁(X)) -> TOP₁(active₁(X))
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> TIMES₂(proper₁(X1), proper₁(X2))
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> FROM₁(s₁(X))
PROPER₁(cons2₂(X1, X2)) -> CONS2₂(proper₁(X1), proper₁(X2))
CONS2₂(X1, mark₁(X2)) -> CONS2₂(X1, X2)
PROPER₁(posrecip₁(X)) -> POSRECIP₁(proper₁(X))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(active₁(X1), X2)
NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> POSRECIP₁(Y)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(active₁(X1), X2)
2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
CONS2₂(ok₁(X1), ok₁(X2)) -> CONS2₂(X1, X2)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(X1, active₁(X2))
ACTIVE₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> NEGRECIP₁(Y)
FROM₁(mark₁(X)) -> FROM₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
TOP₁(ok₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
ACTIVE₁(cons2₂(X1, X2)) -> CONS2₂(X1, active₁(X2))
ACTIVE₁(s₁(X)) -> S₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(proper₁(X1), proper₁(X2))
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> RCONS₂(posrecip₁(Y), 2ndsneg₂(N, Z))
TOP₁(mark₁(X)) -> PROPER₁(X)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(square₁(X)) -> TIMES₂(X, X)
PI₁(mark₁(X)) -> PI₁(X)
PROPER₁(rcons₂(X1, X2)) -> RCONS₂(proper₁(X1), proper₁(X2))
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> 2NDSNEG₂(N, Z)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)
PROPER₁(s₁(X)) -> S₁(proper₁(X))
S₁(ok₁(X)) -> S₁(X)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
SQUARE₁(ok₁(X)) -> SQUARE₁(X)
ACTIVE₁(from₁(X)) -> CONS₂(X, from₁(s₁(X)))
CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)
ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(plus₂(s₁(X), Y)) -> PLUS₂(X, Y)
PROPER₁(plus₂(X1, X2)) -> PLUS₂(proper₁(X1), proper₁(X2))
TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
ACTIVE₁(posrecip₁(X)) -> POSRECIP₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> S₁(X)
NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)
PROPER₁(cons₂(X1, X2)) -> CONS₂(proper₁(X1), proper₁(X2))
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)
CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)
ACTIVE₁(plus₂(s₁(X), Y)) -> S₁(plus₂(X, Y))
FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 16 SCCs with 53 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SQUARE₁(ok₁(X)) -> SQUARE₁(X)
SQUARE₁(mark₁(X)) -> SQUARE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SQUARE₁(ok₁(X)) -> SQUARE₁(X)

The remaining pairs can at least be oriented weakly.

SQUARE₁(mark₁(X)) -> SQUARE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( SQUARE₁(x₁) ) = max{0, x₁ - 1}

POL( ok₁(x₁) ) = x₁ + 2

POL( mark₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SQUARE₁(mark₁(X)) -> SQUARE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SQUARE₁(mark₁(X)) -> SQUARE₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( SQUARE₁(x₁) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)
TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)

The remaining pairs can at least be oriented weakly.

TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( TIMES₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

POL( mark₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)

The remaining pairs can at least be oriented weakly.

TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( TIMES₂(x₁, x₂) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( TIMES₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( mark₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)
PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PLUS₂(x₁, x₂) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PLUS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PLUS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PI₁(mark₁(X)) -> PI₁(X)
PI₁(ok₁(X)) -> PI₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PI₁(mark₁(X)) -> PI₁(X)

The remaining pairs can at least be oriented weakly.

PI₁(ok₁(X)) -> PI₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PI₁(x₁) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PI₁(ok₁(X)) -> PI₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PI₁(ok₁(X)) -> PI₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PI₁(x₁) ) = max{0, x₁ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 2NDSNEG₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 2NDSNEG₂(x₁, x₂) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 2NDSNEG₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 2NDSPOS₂(x₁, x₂) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 2NDSPOS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 2NDSPOS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM₁(mark₁(X)) -> FROM₁(X)
FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

FROM₁(mark₁(X)) -> FROM₁(X)

The remaining pairs can at least be oriented weakly.

FROM₁(ok₁(X)) -> FROM₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( FROM₁(x₁) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

FROM₁(ok₁(X)) -> FROM₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( FROM₁(x₁) ) = max{0, x₁ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( RCONS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( RCONS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( RCONS₂(x₁, x₂) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS2₂(X1, mark₁(X2)) -> CONS2₂(X1, X2)
CONS2₂(ok₁(X1), ok₁(X2)) -> CONS2₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CONS2₂(X1, mark₁(X2)) -> CONS2₂(X1, X2)

The remaining pairs can at least be oriented weakly.

CONS2₂(ok₁(X1), ok₁(X2)) -> CONS2₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( CONS2₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS2₂(ok₁(X1), ok₁(X2)) -> CONS2₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CONS2₂(ok₁(X1), ok₁(X2)) -> CONS2₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( CONS2₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)
CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( CONS₂(x₁, x₂) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( CONS₂(x₁, x₂) ) = max{0, x₂ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)
NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)

The remaining pairs can at least be oriented weakly.

NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( NEGRECIP₁(x₁) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( NEGRECIP₁(x₁) ) = max{0, x₁ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)
POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)

The remaining pairs can at least be oriented weakly.

POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( POSRECIP₁(x₁) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

POL( ok₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( POSRECIP₁(x₁) ) = max{0, x₁ - 1}

POL( ok₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

S₁(ok₁(X)) -> S₁(X)
S₁(mark₁(X)) -> S₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

S₁(ok₁(X)) -> S₁(X)

The remaining pairs can at least be oriented weakly.

S₁(mark₁(X)) -> S₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( S₁(x₁) ) = max{0, x₁ - 1}

POL( ok₁(x₁) ) = x₁ + 2

POL( mark₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

S₁(mark₁(X)) -> S₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

S₁(mark₁(X)) -> S₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( S₁(x₁) ) = max{0, x₁ - 1}

POL( mark₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(pi₁(X)) -> PROPER₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(pi₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( pi₁(x₁) ) = x₁ + 2

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( cons2₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( square₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)

The remaining pairs can at least be oriented weakly.

PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( cons₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( cons2₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( square₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)

The remaining pairs can at least be oriented weakly.

PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( cons2₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( square₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(cons2₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( cons2₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( square₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( square₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(s₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( s₁(x₁) ) = x₁ + 2

POL( square₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(square₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( square₁(x₁) ) = x₁ + 2

POL( from₁(x₁) ) = x₁

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(from₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( from₁(x₁) ) = x₁ + 2

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)

The remaining pairs can at least be oriented weakly.

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( negrecip₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(posrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( negrecip₁(x₁) ) = x₁ + 2

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(posrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(posrecip₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( PROPER₁(x₁) ) = max{0, x₁ - 1}

POL( posrecip₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ QDPOrderProof

                                                              ↳ QDP

                                                                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(cons2₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(cons2₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( cons₂(x₁, x₂) ) = x₁ + 2

POL( cons2₂(x₁, x₂) ) = x₂

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( square₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(cons2₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(cons2₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( cons2₂(x₁, x₂) ) = x₂ + 2

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( square₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( 2ndspos₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( posrecip₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( square₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( plus₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( posrecip₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( negrecip₁(x₁) ) = x₁

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( square₁(x₁) ) = x₁

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( 2ndsneg₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( negrecip₁(x₁) ) = x₁

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( square₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( negrecip₁(x₁) ) = x₁ + 2

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( square₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( times₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( square₁(x₁) ) = x₁

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(square₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( square₁(x₁) ) = x₁ + 2

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( rcons₂(x₁, x₂) ) = x₁ + x₂ + 2

POL( from₁(x₁) ) = x₁

POL( pi₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(from₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( from₁(x₁) ) = x₁ + 2

POL( pi₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( pi₁(x₁) ) = x₁ + 2

POL( s₁(x₁) ) = x₁

POL( posrecip₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( posrecip₁(x₁) ) = x₁ + 2

POL( s₁(x₁) ) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( ACTIVE₁(x₁) ) = max{0, x₁ - 1}

POL( s₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ QDPOrderProof

                                                              ↳ QDP

                                                                ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TOP₁(ok₁(X)) -> TOP₁(active₁(X))
TOP₁(mark₁(X)) -> TOP₁(proper₁(X))

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndspos₂(s₁(N), cons2₂(X, Z)))
active₁(2ndspos₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, Z))) -> mark₁(2ndsneg₂(s₁(N), cons2₂(X, Z)))
active₁(2ndsneg₂(s₁(N), cons2₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(cons2₂(X1, X2)) -> cons2₂(X1, active₁(X2))
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
cons2₂(X1, mark₁(X2)) -> mark₁(cons2₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(cons2₂(X1, X2)) -> cons2₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
cons2₂(ok₁(X1), ok₁(X2)) -> ok₁(cons2₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.